home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 429_01 / chess12 / chess.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-29  |  8.6 KB  |  307 lines
  1. #if !defined(CHESS_HPP)
  2. #define CHESS_HPP
  3.  
  4. #include "misc.hpp"
  5. #include "brdsize.hpp"
  6.  
  7. enum PIECECOLOR { WHITE, BLACK };
  8.  
  9. inline PIECECOLOR OtherColor(PIECECOLOR c)
  10.   { return(c == WHITE ? BLACK : WHITE); }
  11.  
  12. enum PIECETYPE { TYPEKING, TYPEQUEEN, TYPEBISHOP, TYPEKNIGHT,
  13.                  TYPEROOK, TYPEPAWN, TYPENOPIECE };
  14.  
  15. // simple completion status of a move
  16. enum MOVEEVAL
  17.   {
  18.     // move done (not an en passant capture)
  19.     MOVEDONE,
  20.     // en passant capture move performed
  21.     MOVEENPASSANT,
  22.     // move not performed because it is illegal
  23.     ILLEGALMOVE,
  24.     // move not performed because if would allow opponent to take
  25.     // king on next move
  26.     WOULDLOSEKING
  27.   };
  28.  
  29. // full completion status of move
  30. class MOVESTATUS
  31.   {
  32.   public:
  33.     // simple completions status
  34.     MOVEEVAL status;
  35.     // if status is WOULDLOSEKING, dangerToKing specifies the position
  36.     // of the opponent piece that would take the king on the nex move
  37.     POSITION dangerToKing;
  38.  
  39.     MOVESTATUS(void) { };
  40.  
  41.     // constructor if status is not WOULDLOSEKING
  42.     MOVESTATUS(MOVEEVAL s) : status(s) { };
  43.     // constructor if status is WOULDLOSEKING
  44.     MOVESTATUS(MOVEEVAL s, POSITION p) : status(s), dangerToKing(p) { };
  45.   };
  46.  
  47. // specifies a move
  48. enum MOVETYPE { KINGSIDECASTLE, QUEENSIDECASTLE, NORMALMOVE };
  49. class PIECEMOVE
  50.   {
  51.   public:
  52.     MOVETYPE type;
  53.     POSITION start, end;
  54.     // if moved piece is pawn which has thus arrived last rank, the
  55.     // type of the piece to promote it to.  set to TYPENOPIECE if no
  56.     // promotion.
  57.     PIECETYPE promoteType;
  58.  
  59.     PIECEMOVE(void) { }
  60.  
  61.     PIECEMOVE
  62.       (
  63.     MOVETYPE t,
  64.     POSITION s,
  65.     POSITION e,
  66.     PIECETYPE pT = TYPENOPIECE
  67.       ) : type(t), start(s), end(e), promoteType(pT) { }
  68.  
  69.     // constructor for castling moves
  70.     PIECEMOVE
  71.       (
  72.     MOVETYPE t
  73.       ) : type(t) { }
  74.   };
  75.  
  76. class PIECE;
  77.  
  78. // records whether the current move is an en passant capture, or
  79. // follows a two-rank move of a pawn
  80. enum EFFECTENPASSANT { ENPASSANTCAPTURE, AFTERDOUBLEMOVE, OTHERMOVE };
  81. // information (other than the starting and end piece position)
  82. // required to undo the effects of moving a piece
  83. class MOVEUNDODATA
  84.   {
  85.   public:
  86.     // if not null, piece captured by moving piece
  87.     PIECE *capturedPiece;
  88.     // en passant effect
  89.     EFFECTENPASSANT enPassantEffect;
  90.     // if enPassantEffect not OTHERMOVE, records position of
  91.     // previously double-moved pawn
  92.     POSITION saveDoubleMoved;
  93.   };
  94.  
  95. // evalution of change in relative situation of the two players after
  96. // one or more moves
  97. enum SITUATIONOFKING { KINGLOST, STALEMATE, KINGOK };
  98. class BOARDMETRIC
  99.   {
  100.   public:
  101.     SITUATIONOFKING kingSituation[2]; // indexed by PIECECOLOR
  102.     // change in relative material (total white material -
  103.     // total black material)
  104.     int materialDiff;
  105.   };
  106.  
  107. // maximum number of pieces of one color on the board
  108. const int MAXPIECES = 16;
  109.  
  110. // maximum number of locations that a piece can reach in
  111. // a single move
  112. const int MAXMOVES = 28;
  113.  
  114. // list of moves which result in the greatest gain (or least loss)
  115. // of material.
  116. class BESTMOVES
  117.   {
  118.   public:
  119.     // number of moves in list
  120.     int nMoves;
  121.     PIECEMOVE move[MAXPIECES * MAXMOVES];
  122.   };
  123.  
  124. // internal representation of chess board
  125. class BOARD
  126.   {
  127.   private:
  128.     // location in brd array points to piece in corresponding position
  129.     // on chess board.  a null pointer means no piece in that location.
  130.     PIECE *brd[NUMROWS][NUMCOLS];
  131.     // flags if the last move was a double pawn move
  132.     BOOL wasLastMoveDoublePawn;
  133.     // if last move was double pawn move, contains the ending position
  134.     // of the pawn.
  135.     POSITION doubleMovedPawn;
  136.  
  137.     // recursive function to find optimal moves in terms of
  138.     // getting opponent in checkmate or material gain.
  139.     void helpFindBestMoves
  140.       (
  141.         // number of moves to look-ahead
  142.         int lookAhead,
  143.     // color of player that is going to move
  144.         PIECECOLOR moveColor,
  145.     // metric of optimal moves
  146.         BOARDMETRIC &metric,
  147.     // if not null, filled in with list of optimal moves
  148.         BESTMOVES *bestMoves
  149.       );
  150.  
  151.   public:
  152.     BOARD(void);
  153.     ~BOARD(void);
  154.  
  155.     PIECE *whatPiece(POSITION p) const
  156.       { return(brd[p.row][p.col]); }
  157.  
  158.     PIECE *whatPiece(int row, int col) const
  159.       { return(brd[row][col]); }
  160.  
  161.     // perform a move.  move is not validated (assumed to be legal).
  162.     void doMove
  163.       (
  164.     // starting and ending position of piece to move
  165.     POSITION start,
  166.     POSITION end,
  167.     // data needed to undo move.  caller must delete captured
  168.     // piece (unless move is undone)
  169.     MOVEUNDODATA &undoData
  170.       );
  171.  
  172.     // undo a move done with doMove
  173.     void undoMove
  174.       (
  175.         // ending and original position of piece (transposed of order
  176.     // as passed to doMove)
  177.     POSITION end,
  178.     POSITION orig,
  179.     // undo data returned by call to doMove
  180.     MOVEUNDODATA undoData
  181.       );
  182.  
  183.     // returns TRUE if the king of the given color can castle on the
  184.     // given side (as given by whichCastle).  the one preventing
  185.     // condition not cheched for is if the final position of the king
  186.     // places it in check.
  187.     BOOL canCastle(MOVETYPE whichCastle, PIECECOLOR color);
  188.  
  189.     // do a castle on the given side with the king of given color.
  190.     // no validation, assumed to be legal.
  191.     void castle(MOVETYPE whichCastle, PIECECOLOR color,
  192.             MOVEUNDODATA &undoData);
  193.     // undo a castle.  undoData must be as returned by castle member.
  194.     void undoCastle(MOVETYPE whichCastle, PIECECOLOR color,
  195.             MOVEUNDODATA &undoData);
  196.  
  197.     // checks if the piece in the given position can be promoted.
  198.     BOOL canPromote(POSITION where);
  199.     // promotes pawn in given location to piece of given type.
  200.     // assumed to be legal, no validation.
  201.     void promote(POSITION where, PIECETYPE promoteType);
  202.     // "un-promotes" a piece back to being a pawn.  won't work if
  203.     // the piece was not originally a pawn.
  204.     void restorePawn(POSITION where);
  205.  
  206.     // do a move with full validation, returning status
  207.     MOVESTATUS doUserMove
  208.       (
  209.         // starting and ending position of piece.  the starting
  210.         // position is assumed to be valid.
  211.     POSITION start,
  212.     POSITION end
  213.       );
  214.  
  215.     // complete check of whether a castle move can be done
  216.     BOOL userCanCastle(MOVETYPE whichCastle, PIECECOLOR color);
  217.  
  218.     // returns TRUE if the last move was a double pawn move.  if
  219.     // TRUE, the ending position of the pawn is returned as well.
  220.     BOOL lastMoveDoublePawn(POSITION &whereDoubleMovedPawn) const
  221.       { 
  222.     if (wasLastMoveDoublePawn)
  223.       whereDoubleMovedPawn = doubleMovedPawn;
  224.     return(wasLastMoveDoublePawn);
  225.       }
  226.  
  227.     // front end for helpFindBestMoves.  simply initializes the
  228.     // material change to 0.
  229.     void findBestMoves
  230.       (
  231.         int lookAhead,
  232.         PIECECOLOR moveColor,
  233.         BOARDMETRIC &metric,
  234.         BESTMOVES *bestMoves
  235.       )
  236.       {
  237.     metric.materialDiff = 0;
  238.  
  239.     helpFindBestMoves(lookAhead, moveColor, metric, bestMoves);
  240.  
  241.     return;
  242.       }
  243.  
  244.   };
  245.  
  246. // list of possible ending positions if a piece is moved from a fixed
  247. // starting positions
  248. class POSITIONLIST
  249.   {
  250.   public:
  251.     // number of ending positions
  252.     int nMoves;
  253.     POSITION end[MAXMOVES];
  254.   };
  255.  
  256. // abstract base class for piece.
  257. class PIECE
  258.   {
  259.   private:
  260.     const PIECECOLOR color;
  261.     const PIECETYPE type;
  262.     // material value of piece.
  263.     const int value;
  264.     // number of moves piece has made.
  265.     int moveCount;
  266.  
  267.   public:
  268.  
  269.     PIECE(PIECECOLOR c, PIECETYPE t, int v) :
  270.       color(c), type(t), value(v), moveCount(0)
  271.       { }
  272.     virtual ~PIECE(void) { }
  273.  
  274.     PIECECOLOR whatColor(void) const { return(color); }
  275.  
  276.     virtual PIECETYPE whatType(void) const { return(type); }
  277.  
  278.     virtual int whatValue(void) const { return(value); }
  279.  
  280.     // material value of piece where white is positive and
  281.     // black is negative
  282.     int signedValue(void) const
  283.       { return(color == WHITE ? whatValue() : -whatValue()); }
  284.  
  285.     // tell piece it was moved (once)
  286.     void moveDone(void) { moveCount++; }
  287.     // tell piece it was "unmoved"
  288.     void moveUndone(void) { moveCount--; }
  289.     // ask piece if it has been moved at least once
  290.     BOOL hasBeenMoved(void) const { return(moveCount > 0); }
  291.  
  292.     // return list of legal moves for the piece
  293.     virtual void legalMoves
  294.       (
  295.     // tell piece where it is in board
  296.     POSITION start,
  297.     // give it the board, so it knows where other pieces are
  298.     const BOARD &board,
  299.     // struture to fill with ending positions of legal moves
  300.     // from the given start
  301.         POSITIONLIST &moves
  302.       ) const = 0;
  303.  
  304.   };
  305.  
  306. #endif
  307.